package com.ruoyi.rcpt.rdwj.service.impl;

import java.util.List;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.rcpt.rdwj.domain.Rdwj;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import com.ruoyi.common.utils.StringUtils;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.rcpt.rdwj.domain.RdwjFj;
import com.ruoyi.rcpt.rdwj.mapper.RdwjMapper;
import com.ruoyi.rcpt.rdwj.service.IRdwjService;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;

/**
 * 认定文件Service业务层处理
 *
 * @author huacai
 * @date 2024-11-12
 */
@Service
public class RdwjServiceImpl implements IRdwjService
{
    @Resource
    private RdwjMapper rdwjMapper;

    @Resource
    private SqlSessionFactory sqlSessionFactory;

    /**
     * 查询认定文件
     *
     * @param rdwjId 认定文件主键
     * @return 认定文件
     */
    @Override
    public Rdwj selectRdwjByRdwjId(String rdwjId)
    {
        return rdwjMapper.selectRdwjByRdwjId(rdwjId);
    }

    /**
     * 查询认定文件列表
     *
     * @param rdwj 认定文件
     * @return 认定文件
     */
    @Override
    public List<Rdwj> selectRdwjList(Rdwj rdwj)
    {
        return rdwjMapper.selectRdwjList(rdwj);
    }

    /**
     * 新增认定文件
     *
     * @param rdwj 认定文件
     * @return 结果
     */
    @Transactional
    @Override
    public int insertRdwj(Rdwj rdwj)
    {
        rdwj.setCreateTime(DateUtils.getNowDate());
        rdwj.setIdWhere("存在");
        int rows = rdwjMapper.insertRdwj(rdwj);
        insertRdwjFj(rdwj);
        return rows;
    }

    /**
     * 批量新增认定文件
     *
     * @param rdwjs 认定文件List
     * @return 结果
     */
    @Override
    public int batchInsertRdwj(List<Rdwj> rdwjs)
    {
        SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH, false);
        int count = 0;
        if (!CollectionUtils.isEmpty(rdwjs)) {
            try {
                for (int i = 0; i < rdwjs.size(); i++) {
                    int row = rdwjMapper.insertRdwj(rdwjs.get(i));
                    // 防止内存溢出，每100次提交一次,并清除缓存
                    boolean bool = (i >0 && i%100 == 0) || i == rdwjs.size() - 1;
                    if (bool){
                        sqlSession.commit();
                        sqlSession.clearCache();
                    }
                    count = i + 1;
                }
            }catch (Exception e){
                e.printStackTrace();
                // 没有提交的数据可以回滚
                sqlSession.rollback();
            }finally {
                sqlSession.close();
                return count;
            }
        }
        return count;
    }

    /**
     * 修改认定文件
     *
     * @param rdwj 认定文件
     * @return 结果
     */
    @Transactional
    @Override
    public int updateRdwj(Rdwj rdwj)
    {
        rdwj.setUpdateTime(DateUtils.getNowDate());
//        rdwjMapper.deleteRdwjFjByRdwjId(rdwj.getRdwjId());
        insertRdwjFj(rdwj);
        return rdwjMapper.updateRdwj(rdwj);
    }

    /**
     * 批量删除认定文件
     *
     * @param rdwjIds 需要删除的认定文件主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteRdwjByRdwjIds(String[] rdwjIds)
    {
        rdwjMapper.deleteRdwjFjByRdwjIds(rdwjIds);
        return rdwjMapper.deleteRdwjByRdwjIds(rdwjIds);
    }

    /**
     * 删除认定文件信息
     *
     * @param rdwjId 认定文件主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteRdwjByRdwjId(String rdwjId)
    {
        rdwjMapper.deleteRdwjFjByRdwjId(rdwjId);
        return rdwjMapper.deleteRdwjByRdwjId(rdwjId);
    }

    @Override
    public int insertrdwjFjByrcptId(RdwjFj rdwjFj) {
        return rdwjMapper.insertrdwjFjByrcptId(rdwjFj);
    }

    /**
     * 根据ID查询附件列表
     */
    @Override
    public List<RdwjFj> selectRdwjFjList(RdwjFj rdwjFj) {
        return rdwjMapper.selectRdwjFjList(rdwjFj);
    }

    /**
     * 删除认定文件附件
     */
    @Override
    public int deleteRdwjFjByFjIds(Integer[] fjIds) {
        return rdwjMapper.deleteRdwjFjByFjIds(fjIds);
    }

    /**
     * 新增认定文件附件信息
     *
     * @param rdwj 认定文件对象
     */
    public void insertRdwjFj(Rdwj rdwj)
    {
        List<RdwjFj> rdwjFjList = rdwj.getRdwjFjList();
        String rdwjId = rdwj.getRdwjId();
        if (StringUtils.isNotNull(rdwjFjList))
        {
            List<RdwjFj> list = new ArrayList<RdwjFj>();
            for (RdwjFj rdwjFj : rdwjFjList)
            {
                rdwjFj.setRdwjId(rdwjId);
                list.add(rdwjFj);
            }
//            if (list.size() > 0)
//            {
//                rdwjMapper.batchRdwjFj(list);
//            }
        }
    }
}
